#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
天翼云盘PC版客户端
重构后的主客户端类，整合基础操作、文件操作和文件管理功能
"""

import os
import sys
import argparse
from typing import Dict, List, Optional, Any, Union, BinaryIO

from .base_client import BaseCloud189Client
from .file_operations import FileOperations
from .file_management import FileManagement

class Cloud189PCClient(BaseCloud189Client, FileOperations, FileManagement):
    """天翼云盘PC版客户端
    
    整合了基础操作、文件操作和文件管理功能的完整客户端
    """
    
    def __init__(self, cache_file: str = "data/db/cache_189.json", enable_debug: bool = False):
        """初始化客户端
        
        Args:
            cache_file: 缓存文件路径
            enable_debug: 是否启用调试模式
        """
        super().__init__(cache_file, enable_debug)
    
    def parse_file_info(self, file_data: Dict[str, Any]) -> Dict[str, Any]:
        """解析文件信息
        
        Args:
            file_data: 原始文件数据
            
        Returns:
            解析后的文件信息
        """
        return {
            'id': file_data.get('id'),
            'name': file_data.get('name'),
            'size': file_data.get('size', 0),
            'type': 'file',
            'lastOpTime': file_data.get('lastOpTime'),
            'createDate': file_data.get('createDate'),
            'md5': file_data.get('md5'),
            'mediaType': file_data.get('mediaType'),
            'icon': file_data.get('icon'),
            'downloadUrl': file_data.get('downloadUrl')
        }
    
    def parse_folder_info(self, folder_data: Dict[str, Any]) -> Dict[str, Any]:
        """解析文件夹信息
        
        Args:
            folder_data: 原始文件夹数据
            
        Returns:
            解析后的文件夹信息
        """
        return {
            'id': folder_data.get('id'),
            'name': folder_data.get('name'),
            'type': 'folder',
            'lastOpTime': folder_data.get('lastOpTime'),
            'createDate': folder_data.get('createDate'),
            'fileCount': folder_data.get('fileCount', 0),
            'folderCount': folder_data.get('folderCount', 0)
        }
    
    def parse_files_response(self, response_data: Dict[str, Any]) -> Dict[str, Any]:
        """解析文件列表响应
        
        Args:
            response_data: API响应数据
            
        Returns:
            解析后的文件列表数据
        """
        if not response_data or response_data.get('res_code') != 0:
            return {'files': [], 'folders': [], 'total': 0}
        
        file_list_ao = response_data.get('fileListAO', {})
        
        # 解析文件列表
        files = []
        for file_data in file_list_ao.get('fileList', []):
            files.append(self.parse_file_info(file_data))
        
        # 解析文件夹列表
        folders = []
        for folder_data in file_list_ao.get('folderList', []):
            folders.append(self.parse_folder_info(folder_data))
        
        return {
            'files': files,
            'folders': folders,
            'total': file_list_ao.get('count', 0),
            'fileCount': len(files),
            'folderCount': len(folders)
        }
    
    # 兼容性方法：保持原有的上传接口
    def upload_file(self, file_path: str, parent_id: str = "-11", is_family: bool = False, 
                   overwrite: bool = True, try_fast_upload: bool = True) -> Optional[Dict[str, Any]]:
        """上传文件（兼容性方法）
        
        Args:
            file_path: 文件路径
            parent_id: 父目录ID
            is_family: 是否为家庭云
            overwrite: 是否覆盖同名文件
            try_fast_upload: 是否尝试秒传
            
        Returns:
            上传成功返回文件信息，失败返回None
        """
        if not os.path.exists(file_path):
            print(f"文件不存在: {file_path}")
            return None
        
        filename = os.path.basename(file_path)
        return self.upload_file_stream(file_path, filename, parent_id, is_family, overwrite, try_fast_upload)
    
    def fast_upload(self, file_path: str, parent_id: str = "-11", is_family: bool = False) -> Optional[Dict[str, Any]]:
        """快速上传（秒传检查）
        
        Args:
            file_path: 文件路径
            parent_id: 父目录ID
            is_family: 是否为家庭云
            
        Returns:
            秒传成功返回文件信息，否则返回None
        """
        if not os.path.exists(file_path):
            print(f"文件不存在: {file_path}")
            return None
        
        filename = os.path.basename(file_path)
        file_size = os.path.getsize(file_path)
        file_md5 = self.calculate_file_md5(file_path)
        
        return self.check_fast_upload(filename, file_size, file_md5, parent_id, is_family)
    
    def stream_upload(self, file_data: Union[str, bytes, BinaryIO], filename: str, 
                     parent_id: str = "-11", is_family: bool = False, 
                     overwrite: bool = True) -> Optional[Dict[str, Any]]:
        """流式上传（新接口）
        
        Args:
            file_data: 文件数据（文件路径、字节数据或文件对象）
            filename: 文件名
            parent_id: 父目录ID
            is_family: 是否为家庭云
            overwrite: 是否覆盖同名文件
            
        Returns:
            上传成功返回文件信息，失败返回None
        """
        return self.upload_file_stream(file_data, filename, parent_id, is_family, overwrite, False)

def main():
    """命令行主函数"""
    parser = argparse.ArgumentParser(description='天翼云盘PC版客户端')
    parser.add_argument('--username', '-u', help='用户名')
    parser.add_argument('--password', '-p', help='密码')
    parser.add_argument('--cache', '-c', default='cloud189_cache.json', help='缓存文件路径')
    parser.add_argument('--debug', '-d', action='store_true', help='启用调试模式')
    parser.add_argument('--family', '-f', action='store_true', help='家庭云模式')
    
    subparsers = parser.add_subparsers(dest='command', help='可用命令')
    
    # 登录命令
    login_parser = subparsers.add_parser('login', help='登录')
    
    # 列表命令
    list_parser = subparsers.add_parser('ls', help='列出文件')
    list_parser.add_argument('folder_id', nargs='?', default='-11', help='文件夹ID')
    
    # 上传命令
    upload_parser = subparsers.add_parser('upload', help='上传文件')
    upload_parser.add_argument('file_path', help='文件路径')
    upload_parser.add_argument('--parent', '-p', default='-11', help='父目录ID')
    upload_parser.add_argument('--fast', action='store_true', help='仅尝试秒传')
    upload_parser.add_argument('--stream', action='store_true', help='使用流式上传')
    
    # 下载命令
    download_parser = subparsers.add_parser('download', help='下载文件')
    download_parser.add_argument('file_id', help='文件ID')
    download_parser.add_argument('save_path', help='保存路径')
    download_parser.add_argument('--filename', help='文件名')
    
    # 创建目录命令
    mkdir_parser = subparsers.add_parser('mkdir', help='创建目录')
    mkdir_parser.add_argument('name', help='目录名')
    mkdir_parser.add_argument('--parent', '-p', default='-11', help='父目录ID')
    
    # 删除命令
    delete_parser = subparsers.add_parser('delete', help='删除文件')
    delete_parser.add_argument('file_id', help='文件ID')
    
    # 重命名命令
    rename_parser = subparsers.add_parser('rename', help='重命名文件')
    rename_parser.add_argument('file_id', help='文件ID')
    rename_parser.add_argument('new_name', help='新名称')
    
    # 移动命令
    move_parser = subparsers.add_parser('move', help='移动文件')
    move_parser.add_argument('file_id', help='文件ID')
    move_parser.add_argument('target_folder_id', help='目标文件夹ID')
    
    # 复制命令
    copy_parser = subparsers.add_parser('copy', help='复制文件')
    copy_parser.add_argument('file_id', help='文件ID')
    copy_parser.add_argument('target_folder_id', help='目标文件夹ID')
    
    args = parser.parse_args()
    
    # 创建客户端
    client = Cloud189PCClient(
        username=args.username,
        password=args.password,
        cache_file=args.cache,
        enable_debug=args.debug
    )
    
    # 处理命令
    if args.command == 'login' or not client.is_login():
        if not client.auto_login():
            username = args.username or input("请输入用户名: ")
            password = args.password or input("请输入密码: ")
            if not client.login(username, password):
                print("登录失败")
                return
    
    if args.command == 'ls':
        result = client.get_files(args.folder_id, args.family)
        if result:
            parsed = client.parse_files_response(result)
            print(f"文件夹: {parsed['folderCount']} 个")
            for folder in parsed['folders']:
                print(f"[DIR]  {folder['name']} (ID: {folder['id']})")
            print(f"文件: {parsed['fileCount']} 个")
            for file in parsed['files']:
                size_str = f"{file['size']:,} bytes" if file['size'] else "未知大小"
                print(f"[FILE] {file['name']} ({size_str}) (ID: {file['id']})")
        else:
            print("获取文件列表失败")
    
    elif args.command == 'upload':
        if args.fast:
            result = client.fast_upload(args.file_path, args.parent, args.family)
        elif args.stream:
            filename = os.path.basename(args.file_path)
            result = client.stream_upload(args.file_path, filename, args.parent, args.family)
        else:
            result = client.upload_file(args.file_path, args.parent, args.family)
        
        if result:
            print(f"上传成功: {result}")
        else:
            print("上传失败")
    
    elif args.command == 'download':
        if client.download_file(args.file_id, args.save_path, args.family, args.filename):
            print("下载成功")
        else:
            print("下载失败")
    
    elif args.command == 'mkdir':
        result = client.make_dir(args.parent, args.name, args.family)
        if result:
            print(f"创建目录成功: {args.name} (ID: {result})")
        else:
            print("创建目录失败")
    
    elif args.command == 'delete':
        if client.delete_file(args.file_id, args.family):
            print("删除成功")
        else:
            print("删除失败")
    
    elif args.command == 'rename':
        if client.rename_file(args.file_id, args.new_name, args.family):
            print("重命名成功")
        else:
            print("重命名失败")
    
    elif args.command == 'move':
        if client.move_file(args.file_id, args.target_folder_id, args.family):
            print("移动成功")
        else:
            print("移动失败")
    
    elif args.command == 'copy':
        if client.copy_file(args.file_id, args.target_folder_id, args.family):
            print("复制成功")
        else:
            print("复制失败")
    
    else:
        parser.print_help()

if __name__ == '__main__':
    main()